
#include "Uart.h"

// 调试的串口
u8 u8_acDebugUartRxBuf[MAX_DEBUG_RX_LEN];
u16 u16_gDebugUartRxLen = 0;
u8 start_dealdata = 0;
uint8_t Serial_RxFlag = 0;
uint8_t Config_AT_mode = 0;
// WIFI模块串口
u8 u8_acWifiUartRxBuf[MAX_WIFI_RX_LEN];
u8 acWifiUartRxComplete = FALSE;
u16 u16_gWifiUartRxLen = 0;
// 485模块串口
u8 u8_485UartRxBuf[MAX_485_RX_LEN];
u8 ac485UartRxComplete = FALSE;
u16 u16_g485UartRxLen = 0;
// 语音模块串口
u8 u8_SoundUartRxBuf[MAX_SOUND_RX_LEN];
u8 acSoundUartRxComplete = FALSE;
u16 u16_gSoundUartRxLen = 0;

void UART_MspInit(USART_TypeDef *uart);
void UART_MspDeInit(USART_TypeDef *uart);
void UART_MspInit(USART_TypeDef *uart)
{
	GPIO_InitTypeDef GPIO_struct;
	GPIO_StructInit(&GPIO_struct);
	if (uart == USART1)
	{
		// 开启USART1和GPIO时钟

		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
		// 配置GPIO端口
		GPIO_InitTypeDef GPIO_struct;
		GPIO_struct.GPIO_Mode = GPIO_Mode_AF_PP; // 发送接口
		GPIO_struct.GPIO_Pin = Uart1_TxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOA, &GPIO_struct);

		GPIO_struct.GPIO_Mode = GPIO_Mode_IPU; // 接收接口
		GPIO_struct.GPIO_Pin = Uart1_RxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOA, &GPIO_struct);
	}
	else if (uart == USART2)
	{
		// 开启USART1和GPIO时钟

		RCC_APB1PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
		// 配置GPIO端口
		GPIO_struct.GPIO_Mode = GPIO_Mode_AF_PP; // 发送接口
		GPIO_struct.GPIO_Pin = Uart2_TxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOA, &GPIO_struct);

		GPIO_struct.GPIO_Mode = GPIO_Mode_IPU; // 接收接口
		GPIO_struct.GPIO_Pin = Uart2_RxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOA, &GPIO_struct);
	}
	else if (uart == USART3)
	{

		RCC_APB1PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
		// 配置GPIO端口
		GPIO_struct.GPIO_Mode = GPIO_Mode_AF_PP; // 发送接口
		GPIO_struct.GPIO_Pin = Uart3_TxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOB, &GPIO_struct);

		GPIO_struct.GPIO_Mode = GPIO_Mode_IPU; // 接收接口
		GPIO_struct.GPIO_Pin = Uart3_RxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOB, &GPIO_struct);
	}
	else if (uart == UART4)
	{
		RCC_APB1PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
		// 配置GPIO端口
		GPIO_struct.GPIO_Mode = GPIO_Mode_AF_PP; // 发送接口
		GPIO_struct.GPIO_Pin = Uart4_TxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOC, &GPIO_struct);

		GPIO_struct.GPIO_Mode = GPIO_Mode_IPU; // 接收接口
		GPIO_struct.GPIO_Pin = Uart4_RxPin;
		GPIO_struct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOC, &GPIO_struct);
	}
}

void UART_MspDeInit(USART_TypeDef *uart)
{
	GPIO_InitTypeDef GPIO_Struct;
	GPIO_StructInit(&GPIO_Struct);
	if (uart == USART1)
	{
		NVIC_DisableIRQ(USART1_IRQn);
		GPIO_StructInit(&GPIO_Struct);
		GPIO_Struct.GPIO_Mode = GPIO_Mode_AIN; // 接收接口
		GPIO_Struct.GPIO_Pin = Uart1_RxPin | Uart1_TxPin;
		GPIO_Init(GPIOA, &GPIO_Struct);
	}
	else if (uart == USART2)
	{
		NVIC_DisableIRQ(USART2_IRQn);
		GPIO_StructInit(&GPIO_Struct);
		GPIO_Struct.GPIO_Mode = GPIO_Mode_AIN; // 接收接口
		GPIO_Struct.GPIO_Pin = Uart2_RxPin | Uart2_TxPin;
		GPIO_Init(GPIOA, &GPIO_Struct);
	}
	else if (uart == USART3)
	{
		NVIC_DisableIRQ(USART3_IRQn);
		GPIO_StructInit(&GPIO_Struct);
		GPIO_Struct.GPIO_Mode = GPIO_Mode_AIN; // 接收接口
		GPIO_Struct.GPIO_Pin = Uart3_RxPin | Uart3_TxPin;
		GPIO_Init(GPIOB, &GPIO_Struct);
	}
	else if(uart==UART4)
	{
		NVIC_DisableIRQ(UART4_IRQn);
		GPIO_StructInit(&GPIO_Struct);
		GPIO_Struct.GPIO_Mode = GPIO_Mode_AIN; // 接收接口
		GPIO_Struct.GPIO_Pin = Uart4_RxPin | Uart4_TxPin;
		GPIO_Init(GPIOC, &GPIO_Struct);
	}
}

void vBsp_USARTInit(USART_TypeDef *uart, u32 baud)
{

	// 配置USART
	USART_InitTypeDef USART_struct;
	NVIC_InitTypeDef NVIC_Struct;
	USART_StructInit(&USART_struct);

	USART_struct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 不需要硬件流控制
	USART_struct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;				 // 发送模式+接收模式
	USART_struct.USART_Parity = USART_Parity_No;
	USART_struct.USART_StopBits = USART_StopBits_1;		 // 停止位1位
	USART_struct.USART_WordLength = USART_WordLength_8b; // 1个字节长
	if (uart == USART1)
	{
		UART_MspInit(uart);
		USART_struct.USART_BaudRate = baud; // 波特率
		USART_Init(uart, &USART_struct);
		USART_ITConfig(uart, USART_IT_TXE, DISABLE);
		USART_ITConfig(uart, USART_IT_RXNE, DISABLE);
		USART_ITConfig(uart, USART_IT_ERR, DISABLE);
		// 用中断触发，接受信息
		USART_ITConfig(uart, USART_IT_RXNE, ENABLE);
		// 配置NVIC
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

		NVIC_Struct.NVIC_IRQChannel = USART1_IRQn;
		NVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Struct.NVIC_IRQChannelPreemptionPriority = 2;
		NVIC_Struct.NVIC_IRQChannelSubPriority = 0;
		NVIC_Init(&NVIC_Struct);
	}
	else if (uart == USART2)
	{
		UART_MspInit(uart);
		USART_struct.USART_BaudRate = baud; // 波特率
		USART_Init(uart, &USART_struct);
		USART_ITConfig(uart, USART_IT_TXE, DISABLE);
		USART_ITConfig(uart, USART_IT_RXNE, DISABLE);
		USART_ITConfig(uart, USART_IT_ERR, DISABLE);

		USART_ClearFlag(USART2, USART_FLAG_CTS);
		// 用中断触发，接受信息
		USART_ITConfig(uart, USART_IT_RXNE, ENABLE);
		USART_ITConfig(uart, USART_IT_IDLE, ENABLE);
		// 配置NVIC
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

		NVIC_Struct.NVIC_IRQChannel = USART2_IRQn;
		NVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Struct.NVIC_IRQChannelPreemptionPriority = 2;
		NVIC_Struct.NVIC_IRQChannelSubPriority = 0;
		NVIC_Init(&NVIC_Struct);
	}
	else if (uart == USART3)
	{
		UART_MspInit(uart);
		USART_struct.USART_BaudRate = baud; // 波特率
		USART_Init(uart, &USART_struct);
		USART_ITConfig(uart, USART_IT_TXE, DISABLE);
		USART_ITConfig(uart, USART_IT_RXNE, DISABLE);
		USART_ITConfig(uart, USART_IT_ERR, DISABLE);
		// 用中断触发，接受信息
		USART_ITConfig(uart, USART_IT_RXNE, ENABLE);
		// 配置NVIC
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

		NVIC_Struct.NVIC_IRQChannel = USART3_IRQn;
		NVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Struct.NVIC_IRQChannelPreemptionPriority = 2;
		NVIC_Struct.NVIC_IRQChannelSubPriority = 0;
		NVIC_Init(&NVIC_Struct);
	}
	else if (uart == UART4)
	{
		UART_MspInit(uart);
		USART_struct.USART_BaudRate = baud; // 波特率
		USART_Init(uart, &USART_struct);
		USART_ITConfig(uart, USART_IT_TXE, DISABLE);
		USART_ITConfig(uart, USART_IT_RXNE, DISABLE);
		USART_ITConfig(uart, USART_IT_ERR, DISABLE);
		// 用中断触发，接受信息
		USART_ITConfig(uart, USART_IT_RXNE, ENABLE);
		// 配置NVIC
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
		NVIC_Struct.NVIC_IRQChannel = UART4_IRQn;
		NVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Struct.NVIC_IRQChannelPreemptionPriority = 2;
		NVIC_Struct.NVIC_IRQChannelSubPriority = 0;
		NVIC_Init(&NVIC_Struct);
	}
	// 开启控制开关
	USART_Cmd(uart, ENABLE);
}

void vBsp_USARTDeinit(USART_TypeDef *uart)
{
	UART_MspDeInit(uart);
	USART_DeInit(uart);
}

void uart_init(void)
{
	vBsp_USARTInit(DEBUG_UART, 115200);
	vBsp_USARTInit(WIFI_UART, 115200);
	vBsp_USARTInit(RS485_UART, 115200);
	vBsp_USARTInit(SOUND_UART,115200);
}
// 定义串口1发送数据函数
void uart_send_byte(u8 byte, USART_TypeDef *uart)
{
	// 等待发送完毕，stm32 复位是，USART_FLAG_TC为1
	while (USART_GetFlagStatus(uart, USART_FLAG_TC) == RESET)
		;
	// TC为1时，表示DR寄存器里的数据已经被发送走了，DR为空了
	// USART_SendData可以发送下一个字节数据
	USART_SendData(uart, byte);
}

// 发送十六进制数
void uart_send_hex_num(u8 hexBuff[], u16 len, USART_TypeDef *uart)
{

	for (u32 i = 0; i < len; i++)
		uart_send_byte(hexBuff[i], uart);
}

// 发送一个字符串数组
void uart_send_string(u8 str[], USART_TypeDef *uart)
{
	while (*str)
	{
		uart_send_byte(*str++, uart);
	}
}

uint32_t uart_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}
// 可以发送整形的数字
void uart_SendNumber(uint32_t Number, uint8_t Length, USART_TypeDef *uart)
{
	uint8_t i;
	for (i = 0; i < Length; i++)
	{
		uart_send_byte(Number / uart_Pow(10, Length - i - 1) % 10 + '0', uart);
	}
}
#if !ELECT
u8 uart_get_byte(u8 *val, USART_TypeDef *uart) // 返回值表示是否接收到了数据，返回1表示收到，返回0表示没收到， val为接收数据存放的地址
{
	u8 timeout = 0; // u8 最大值为 255
	while ((USART_GetFlagStatus(uart, USART_FLAG_RXNE) == RESET) && (timeout < 250))
		timeout++;

	if (timeout >= 250)
	{
		*val = 0;
		return NO_REC;
	}
	*val = (u8)USART_ReceiveData(uart);
	USART_ClearITPendingBit(uart, USART_IT_RXNE);
	return REC;
}

// len 表示 buf的长度, 返回值为 接收到的数据个数。
u16 uart_get_string(u8 buf[], u16 len, USART_TypeDef *uart)
{
	int i = 0;
	u8 status = 0;
	for (i = 0; i < len; ++i)
	{
		status = uart_get_byte(&buf[i], uart);
		if (0 == status)
			break;
	}

	return i;
}
#endif
// 重定向printf
int fputc(int ch, FILE *f)
{
	uart_send_byte(ch, USART1);
	return ch;
}

void uart_printf(char *format, ...)
{
	static char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	uart_send_string((u8 *)String, USART1);
}

void uart4_printf(char *format, ...)
{
	static char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	uart_send_string((u8 *)String, UART4);
}

#if !ELECT
FLAG_STATUS_T Serial_GetRxFlag(void)
{
	if (REC == Serial_RxFlag)
	{
		Serial_RxFlag = NO_REC;
		return REC;
	}
	return NO_REC;
}
#endif

void USART1_IRQHandler(void)
{
#if !ELECT
	if (u16_gDebugUartRxLen < sizeof(u8_acDebugUartRxBuf))
	{
		static uint8_t RxState = 0;	  // 接收状态
		static uint8_t pRxPacket = 0; // 接收第几个数据
		u8 ucRecvDat;
		uart_get_byte(&ucRecvDat, USART1);
		if (Config_AT_mode == 1)
		{
			if (RxState == STATE_IDLE) // 接收状态为为0，等待包头
			{
				if (ucRecvDat == '@' && Serial_RxFlag == 0) // 包头为@
				{
					RxState = STATE_RECEIVING; // 置接收状态为1
					pRxPacket = 0;			   // 结束数据位清零
				}
			}
			else if (RxState == STATE_RECEIVING) // 如果状态为1
			{
				if (ucRecvDat == '\r') // 如果接收数据位\r
				{
					RxState = STATE_COMPLETE; // 置接收状态为2，等待包尾
				}
				else
				{
					u8_acDebugUartRxBuf[pRxPacket] = ucRecvDat; // 如果不是\r，接收数据
					pRxPacket++;
				}
			}
			else if (RxState == STATE_COMPLETE) // 置接收状态为2
			{
				if (ucRecvDat == '\n') // 结束标志位
				{
					RxState = STATE_IDLE;
					u16_gDebugUartRxLen = pRxPacket - 1;
					u8_acDebugUartRxBuf[pRxPacket] = '\0'; // 结束标志位
					Serial_RxFlag = 1;
				}
			}
		}
		else
		{
			u8_acDebugUartRxBuf[u16_gDebugUartRxLen++] = ucRecvDat;
		}
	}
#endif
}

void USART2_IRQHandler(void)
{
	u8 ucRecvDat = 0;
	if (u16_gWifiUartRxLen < sizeof(u8_acWifiUartRxBuf))
	{
		uart_get_byte(&ucRecvDat, USART2);
		u8_acWifiUartRxBuf[u16_gWifiUartRxLen++] = ucRecvDat;
	}

	if (USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)
	{
		ucRecvDat = USART2->SR;
		ucRecvDat = USART2->DR;
		acWifiUartRxComplete = TRUE;
		USART_ClearITPendingBit(USART2, USART_IT_IDLE);
	}
}

void USART3_IRQHandler(void)
{
	u8 ucRecvDat = 0;
	if (u16_g485UartRxLen < sizeof(u8_485UartRxBuf))
	{
		uart_get_byte(&ucRecvDat, USART3);
		u8_485UartRxBuf[u16_g485UartRxLen++] = ucRecvDat;
	}

	if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)
	{
		ucRecvDat = USART3->SR;
		ucRecvDat = USART3->DR;
		ac485UartRxComplete = TRUE;
		USART_ClearITPendingBit(USART3, USART_IT_IDLE);
	}
}

void UART4_IRQHandler(void)
{
	u8 ucRecvDat = 0;
	if (u16_gSoundUartRxLen < sizeof(u8_SoundUartRxBuf))
	{
		uart_get_byte(&ucRecvDat, UART4);
		u8_SoundUartRxBuf[u16_gSoundUartRxLen++] = ucRecvDat;
	}

	if (USART_GetITStatus(UART4, USART_IT_IDLE) != RESET)
	{
		ucRecvDat = UART4->SR;
		ucRecvDat = UART4->DR;
		acSoundUartRxComplete = TRUE;
		USART_ClearITPendingBit(UART4, USART_IT_IDLE);
	}
}


uart_t *uartCreate(void)
{
	static uart_t uart;
	uart.PuartInit = uart_init;
	uart.PuartDeinit = vBsp_USARTDeinit;
	uart.PuartSendByte = uart_send_byte;
	uart.PuartSendString = uart_send_string;
	uart.PuartSendHex = uart_send_hex_num;
	uart.PuartSendNumber = uart_SendNumber;
	uart.PuartDBG = uart_printf;
	return &uart;
}
